package com.tbynet.jwp.admin.category;

import java.math.BigInteger;

import com.jfinal.aop.Inject;
import com.jfinal.kit.Ret;
import com.jfinal.kit.StrKit;
import com.jfinal.plugin.activerecord.Page;
import com.tbynet.jwp.admin.AdminController;
import com.tbynet.jwp.service.spi.TermManager;
import com.tbynet.jwp.model.TermTaxonomy;
import com.tbynet.jwp.model.Terms;
import com.tbynet.jwp.repository.spi.TermService;
import com.tbynet.jwp.repository.spi.TermTaxonomyService;
import com.tbynet.jwp.repository.spi.TermRelationshipService;

/**
 * 分类管理控制器
 * @ClassName: CategoryAdminController
 * @Description: 负责分类目录的增删改查操作，只处理HTTP请求和响应，不包含业务逻辑
 * @Author: 佰亿互联
 * @Date: 2025年11月4日
 *
 * @Copyright: 2025 www.tbynet.com Inc. All rights reserved.
 * 注意: 本内容仅限于内部传阅，禁止外泄以及用于其他的商业目
 */
public class CategoryAdminController extends AdminController {

    /** 分类项服务 - 用于分类项相关只读操作 */
    @Inject
    private TermService termService;

    /** 分类法服务 - 用于分类法相关只读操作 */
    @Inject
    private TermTaxonomyService termTaxonomyService;

    /** 分类关系服务 - 用于分类关系相关操作 */
    @Inject
    private TermRelationshipService termRelationshipService;

    /** 分类管理器 - 用于写操作和复杂业务编排 */
    @Inject
    private TermManager termManager;

    // ============ 页面渲染方法 ============

    /**
     * 分类管理首页
     * 职责：渲染分类管理页面，提供分类数据
     */
    public void index() {
        try {
            // 获取分类的父子关系映射，用于页面展示树形结构
            set("parents", termService.getParents(TermTaxonomy.TAXONOMY_CATEGORY));
            render("index.html");
        } catch (Exception e) {
            log.error("渲染分类管理首页异常", e);
            renderError(500);
        }
    }

    /**
     * 编辑分类页面
     * 职责：渲染分类编辑页面，提供分类数据和父级分类数据
     */
    public void edit() {
        try {
            String termId = getPara("term_id");
            if (StrKit.isBlank(termId)) {
                fail("分类ID不能为空");
                return;
            }

            // 获取要编辑的分类信息
            Terms term = termService.getTerm(termId, TermTaxonomy.TAXONOMY_CATEGORY);
            if (term == null) {
                fail("分类不存在");
                return;
            }

            // 获取父级分类数据，用于下拉选择
            set("term", term);
            set("parents", termService.getParents(TermTaxonomy.TAXONOMY_CATEGORY));
            render("edit.html");
        } catch (Exception e) {
            log.error("渲染分类编辑页面异常，termId: {}", getPara("term_id"), e);
            fail("系统异常，请稍后重试");
        }
    }

    // ============ 数据查询方法 ============

    /**
     * 搜索分类
     * 职责：处理分类搜索请求，返回分页数据
     */
    public void search() {
        try {
            String q = getPara("q");
            Page<Terms> page = termService.search(getPage(), getSize(), TermTaxonomy.TAXONOMY_CATEGORY, q);
            ok(Ret.by("data", page));
        } catch (Exception e) {
            log.error("搜索分类异常，关键词: {}", getPara("q"), e);
            fail("搜索失败，请稍后重试");
        }
    }

    // ============ 数据操作方法 ============

    /**
     * 保存分类
     * 职责：处理分类创建请求，调用Manager层进行服务编排
     */
    public void save() {
        try {
            // 参数验证
            if (!validateSaveParams()) {
                return;
            }

            // 构建分类项对象
            Terms term = buildTermFromRequest();

            // 构建分类法对象
            TermTaxonomy taxonomy = buildTaxonomyFromRequest();

            // 使用TermManager创建分类（包含事务管理）
            Ret result = termManager.createTerm(term, taxonomy);
            if (result.isOk()) {
                ok(result);
            } else {
                fail(result.getStr("msg"));
            }
        } catch (Exception e) {
            log.error("保存分类异常", e);
            fail("保存分类失败，请稍后重试");
        }
    }

    /**
     * 更新分类
     * 职责：处理分类更新请求，调用Manager层进行服务编排
     */
    public void update() {
        try {
            // 参数验证
            if (!validateUpdateParams()) {
                return;
            }

            String termId = getPara("term_id");

            // 获取现有分类项
            Terms term = termService.getById(termId);
            if (term == null) {
                fail("分类不存在");
                return;
            }

            // 更新分类项信息
            updateTermFromRequest(term);

            // 获取现有分类法
            TermTaxonomy taxonomy = termTaxonomyService.getTermTaxonomy(term.getTermId(), TermTaxonomy.TAXONOMY_CATEGORY);
            if (taxonomy == null) {
                fail("分类法不存在");
                return;
            }

            // 更新分类法信息
            updateTaxonomyFromRequest(taxonomy);

            // 使用TermManager更新分类（包含事务管理）
            Ret result = termManager.updateTerm(term, taxonomy);
            if (result.isOk()) {
                ok(result);
            } else {
                fail(result.getStr("msg"));
            }
        } catch (Exception e) {
            log.error("更新分类异常，termId: {}", getPara("term_id"), e);
            fail("更新分类失败，请稍后重试");
        }
    }

    /**
     * 删除分类
     * 职责：处理分类删除请求，调用Manager层进行服务编排
     */
    public void delete() {
        try {
            String termId = getPara("term_id");
            if (StrKit.isBlank(termId)) {
                fail("分类ID不能为空");
                return;
            }

            // 验证分类是否存在
            Terms term = termService.getTerm(termId, TermTaxonomy.TAXONOMY_CATEGORY);
            if (term == null) {
                fail("分类不存在");
                return;
            }

            // 检查是否有子分类
            if (termTaxonomyService.hasChildren(termId, TermTaxonomy.TAXONOMY_CATEGORY)) {
                fail("该分类下有子分类，无法删除");
                return;
            }

            // 使用TermManager删除分类（包含事务管理）
            Ret result = termManager.deleteTerm(termId, TermTaxonomy.TAXONOMY_CATEGORY);
            if (result.isOk()) {
                ok(result);
            } else {
                fail(result.getStr("msg"));
            }
        } catch (Exception e) {
            log.error("删除分类异常，termId: {}", getPara("term_id"), e);
            fail("删除分类失败，请稍后重试");
        }
    }

    // ============ 私有方法 - 参数验证 ============

    /**
     * 验证保存操作的参数
     * @return 验证是否通过
     */
    private boolean validateSaveParams() {
        String name = getPara("name");
        if (StrKit.isBlank(name)) {
            fail("分类名称不能为空");
            return false;
        }

        if (name.length() > 200) {
            fail("分类名称长度不能超过200个字符");
            return false;
        }

        return true;
    }

    /**
     * 验证更新操作的参数
     * @return 验证是否通过
     */
    private boolean validateUpdateParams() {
        String termId = getPara("term_id");
        if (StrKit.isBlank(termId)) {
            fail("分类ID不能为空");
            return false;
        }

        return validateSaveParams();
    }

    // ============ 私有方法 - 对象构建 ============

    /**
     * 从请求参数构建分类项对象
     * @return 分类项对象
     */
    private Terms buildTermFromRequest() {
        String name = getPara("name");
        String slug = getPara("slug");

        Terms term = new Terms();
        term.setName(name);
        term.setSlug(StrKit.isBlank(slug) ? name : slug);
        term.setTermGroup(0L);
        return term;
    }

    /**
     * 从请求参数构建分类法对象
     * @return 分类法对象
     */
    private TermTaxonomy buildTaxonomyFromRequest() {
        String description = getPara("description");
        String parent = getPara("parent", "0");

        TermTaxonomy taxonomy = new TermTaxonomy();
        taxonomy.setTaxonomy(TermTaxonomy.TAXONOMY_CATEGORY);
        taxonomy.setDescription(description);
        taxonomy.setParent(new BigInteger(parent));
        taxonomy.setCount(0L);
        return taxonomy;
    }

    /**
     * 从请求参数更新分类项对象
     * @param term 要更新的分类项对象
     */
    private void updateTermFromRequest(Terms term) {
        String name = getPara("name");
        String slug = getPara("slug");

        term.setName(name);
        term.setSlug(StrKit.isBlank(slug) ? name : slug);
    }

    /**
     * 从请求参数更新分类法对象
     * @param taxonomy 要更新的分类法对象
     */
    private void updateTaxonomyFromRequest(TermTaxonomy taxonomy) {
        String description = getPara("description");
        String parent = getPara("parent", "0");

        taxonomy.setDescription(description);
        taxonomy.setParent(new BigInteger(parent));
    }
}